package gameobjects;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;

import javagame.Level;
import javagame.Nivo;
import javagame.Play.difficulty;

import org.newdawn.slick.*;

public class Protivnik {
	
	//NABROJIVI TIPOVI
	
	public enum tip_algoritma {RANDOM, BIRA_SMER, A_ZVEDA}
	public enum tip_protivnika {SIVI, CRNI, TOP, HELIKOPTER, BOSS, BROD, PODMORNICA};
	
	//KONSTANTE
	
	private int[] duration = {200, 200};
	private static int maxBrTop = 30;//maksimalan broj topova koji se mogu nalaziti na protivniku
	
	//POLJA KLASE
	
	private tip_algoritma algoritam;//algoritam po kome se krecu protivnici
	private tip_protivnika vrsta;//vrsta protivnika
	private int HP;//snaga protivnika "helth"
	private Level nivo;
	private Animation eksplozija;
	private float protivnikX;//x pozicija protivnika
	private float protivnikY;//y pozicija protivnika
	private int smer;//smer kretanja
	private int level;
	private boolean ubiven;//da li je protivnik mrtav ili ne;
	private Animation protivnik;//animacija koja je trenutno aktivna
	private Animation movingUp;//animacija za kretanje na gore
	private Animation movingDown;//animacija za kretanje na dole
	private Animation movingLeft;//animacija za kretanje na levo
	private Animation movingRight;//animacija za kretanje na desno
	private int smerOdbrojavanje;//koliko moze da se krece protivnik
	private int metakOdbrojavanje;
	private Igrac igrac;//protivnik mora da bude svestan postojanja igraca
	private Igrac2 igrac2;////protivnik mora da bude svestan postojanja igraca
	private boolean imaDvaIgraca;
	private ArrayList<Metak> meci;//lista metaka koje protivnik ispaljuje
	private boolean blk;
	private int sizeX;//velicina protivnika po x osi
	private int sizeY;//velicina protivnika po x osi
	private int zid;//velicina zida koju protivnik moze da pregazi
	private int zid2;//velicina zida koju protibnik moze da pregazi
	private int brojTopova;//koliko topova ima protivnik
	private KoordinateTopova[] kordTop;//koordinate topova iz kojih se puca	
	private int tenkPomeraj;//kada da protivnik puca na igraca
	private int protivnikPomerajX;//kada da protivnik puca po x
	private int protivnikPomerajY;//kada da protivnik puca po y	
	private boolean shooting;//indikator da li protivnik puca
	private boolean stop;//da li da protivnik stane dok puca
	private boolean shooting2;//indikator da li protivnik puca na drugog igraca
	private boolean stop2;//da li da protivnik stane dok puca na drugog igraca
	private ArrayList<Cvor> trenutniCvorovi;//cvorovi koji su u razmatranju
	private ArrayList<Cvor> put;//cvorovi koji cine put
	private Cvor tekCvor;
	private int indexCvora = 1;
	private int duzinaPuta;
	private boolean path;
	private boolean traziPut;
	private int poslednjeUdario;
	private int pathPucanje;
	private int survivorCount;

	//KONSTRUKTOR
	
	public boolean isPath() {
		return path;
	}

	public void setPath(boolean path) {
		this.path = path;
	}

	public Protivnik(Igrac igrac, Igrac2 igrac2, Level nivo) {
		meci = new ArrayList<Metak>();
		this.nivo = nivo;
		this.igrac = igrac;
		this.igrac2 = igrac2;
		smerOdbrojavanje = 500;
		metakOdbrojavanje = 1;
		protivnikX = 320;
		protivnikY = 160;
		smer = 0;
		ubiven = false;
		blk = false;
		zid = 50;
		zid2 = 0;
		kordTop = new KoordinateTopova[maxBrTop];
		tenkPomeraj = 20;
		protivnikPomerajX = 0;
		protivnikPomerajY = 0;
		shooting = false;
		stop = false;
		shooting2 = false;
		stop2 = false;
		trenutniCvorovi = new ArrayList<Cvor>();
		put = new ArrayList<Cvor>();
		duzinaPuta = 0;
		poslednjeUdario = 0;
		path = false;
		pathPucanje = 30;
		survivorCount = 120;
	}
	
	//GET I SET METODE
	
	public float getProtivnikX() {
		return protivnikX;
	}
	
	public void setProtivnikX(float protivnikX) {
		this.protivnikX = protivnikX;
	}
	
	public float getProtivnikY() {
		return protivnikY;
	}
	
	public void setProtivnikY(float protivnikY) {
		this.protivnikY = protivnikY;
	}
	
	public int getSmer() {
		return smer;
	}
	
	public void setSmer(int smer) {
		this.smer = smer;
	}
	
	public Animation getEksplozija() {
		return eksplozija;
	}

	public void setEksplozija(Animation eksplozija) {
		this.eksplozija = eksplozija;
	}

	public int getLevel() {
		return level;
	}

	public void setLevel(int level) {
		this.level = level;
	}

	public boolean isUbiven() {
		return ubiven;
	}

	public void setUbiven(boolean ubiven) {
		this.ubiven = ubiven;
	}

	public ArrayList<Metak> getMeci() {
		return meci;
	}

	public void setMeci(ArrayList<Metak> meci) {
		this.meci = meci;
	}
	
	public tip_protivnika getVrsta() {
		return vrsta;
	}

	public void setVrsta(tip_protivnika vrsta) {
		this.vrsta = vrsta;
	}

	public Level getNivo() {
		return nivo;
	}

	public void setNivo(Level nivo) {
		this.nivo = nivo;
	}

	public Animation getProtivnik() {
		return protivnik;
	}

	public void setProtivnik(Animation protivnik) {
		this.protivnik = protivnik;
	}

	public Animation getMovingUp() {
		return movingUp;
	}

	public void setMovingUp(Animation movingUp) {
		this.movingUp = movingUp;
	}

	public Animation getMovingDown() {
		return movingDown;
	}

	public void setMovingDown(Animation movingDown) {
		this.movingDown = movingDown;
	}

	public Animation getMovingLeft() {
		return movingLeft;
	}

	public void setMovingLeft(Animation movingLeft) {
		this.movingLeft = movingLeft;
	}

	public Animation getMovingRight() {
		return movingRight;
	}

	public void setMovingRight(Animation movingRight) {
		this.movingRight = movingRight;
	}

	public int getHP() {
		return HP;
	}

	public void setHP(int hP) {
		HP = hP;
	}

	public int getSmerOdbrojavanje() {
		return smerOdbrojavanje;
	}

	public void setSmerOdbrojavanje(int smerOdbrojavanje) {
		this.smerOdbrojavanje = smerOdbrojavanje;
	}

	public int getMetakOdbrojavanje() {
		return metakOdbrojavanje;
	}

	public void setMetakOdbrojavanje(int metakOdbrojavanje) {
		this.metakOdbrojavanje = metakOdbrojavanje;
	}
	
	public int incSmerO() {
		return smerOdbrojavanje--;
	}
	
	public int incMetakO() {
		return metakOdbrojavanje--;
	}
	
	public int[] getDuration() {
		return duration;
	}
	
	public Igrac getIgrac() {
		return igrac;
	}

	public void setIgrac(Igrac igrac) {
		this.igrac = igrac;
	}
	

	public tip_algoritma getAlgoritam() {
		return algoritam;
	}

	public void setAlgoritam(tip_algoritma algoritam) {
		this.algoritam = algoritam;
	}

	public boolean isBlk() {
		return blk;
	}

	public void setBlk(boolean blk) {
		this.blk = blk;
	}

	public void setDuration(int[] duration) {
		this.duration = duration;
	}

	public int getSizeX() {
		return sizeX;
	}

	public void setSizeX(int sizeX) {
		this.sizeX = sizeX;
	}

	public int getSizeY() {
		return sizeY;
	}

	public void setSizeY(int sizeY) {
		this.sizeY = sizeY;
	}
	
	public int getZid() {
		return zid;
	}

	public void setZid(int zid) {
		this.zid = zid;
	}

	public int getBrojTopova() {
		return brojTopova;
	}

	public void setBrojTopova(int brojTopova) {
		this.brojTopova = brojTopova;
	}

	public KoordinateTopova[] getKordTop() {
		return kordTop;
	}

	public void setKordTop(KoordinateTopova[] kordTop) {
		this.kordTop = kordTop;
	}
	
	public KoordinateTopova getKordTop(int index) {
		return kordTop[index];
	}

	public int getTenkPomeraj() {
		return tenkPomeraj;
	}

	public void setTenkPomeraj(int tenkPomeraj) {
		this.tenkPomeraj = tenkPomeraj;
	}

	public int getProtivnikPomerajX() {
		return protivnikPomerajX;
	}

	public void setProtivnikPomerajX(int protivnikPomerajX) {
		this.protivnikPomerajX = protivnikPomerajX;
	}
	
	public int getProtivnikPomerajY() {
		return protivnikPomerajY;
	}

	public void setProtivnikPomerajY(int protivnikPomerajY) {
		this.protivnikPomerajY = protivnikPomerajY;
	}
	
	public boolean isShooting() {
		return shooting;
	}

	public void setShooting(boolean shooting) {
		this.shooting = shooting;
	}

	public boolean isStop() {
		return stop;
	}

	public void setStop(boolean stop) {
		this.stop = stop;
	}
	
	public Igrac2 getIgrac2() {
		return igrac2;
	}

	public void setIgrac2(Igrac2 igrac2) {
		this.igrac2 = igrac2;
	}

	public boolean isImaDvaIgraca() {
		return imaDvaIgraca;
	}

	public void setImaDvaIgraca(boolean imaDvaIgraca) {
		this.imaDvaIgraca = imaDvaIgraca;
	}
	

	public int getPoslednjeUdario() {
		return poslednjeUdario;
	}

	public void setPoslednjeUdario(int poslednjeUdario) {
		this.poslednjeUdario = poslednjeUdario;
	}
	
	public void setTraziPut(boolean traziPut) {
		this.traziPut = traziPut;
	}

	public boolean isTraziPut() {
		return traziPut;
	}

	public boolean isShooting2() {
		return shooting2;
	}

	public void setShooting2(boolean shooting2) {
		this.shooting2 = shooting2;
	}

	public boolean isStop2() {
		return stop2;
	}

	public void setStop2(boolean stop2) {
		this.stop2 = stop2;
	}
	
	public int getZid2() {
		return zid2;
	}

	public void setZid2(int zid2) {
		this.zid2 = zid2;
	}

	public ArrayList<Cvor> getTrenutniCvorovi() {
		return trenutniCvorovi;
	}

	public void setTrenutniCvorovi(ArrayList<Cvor> trenutniCvorovi) {
		this.trenutniCvorovi = trenutniCvorovi;
	}

	public ArrayList<Cvor> getPut() {
		return put;
	}

	public void setPut(ArrayList<Cvor> put) {
		this.put = put;
	}

	public Cvor getTekCvor() {
		return tekCvor;
	}

	public void setTekCvor(Cvor tekCvor) {
		this.tekCvor = tekCvor;
	}

	public int getIndexCvora() {
		return indexCvora;
	}

	public void setIndexCvora(int indexCvora) {
		this.indexCvora = indexCvora;
	}

	public int getDuzinaPuta() {
		return duzinaPuta;
	}

	public void setDuzinaPuta(int duzinaPuta) {
		this.duzinaPuta = duzinaPuta;
	}
	
	public void postaviTezinu () {
		if (Nivo.getTezina() == difficulty.EASY)
			algoritam = tip_algoritma.RANDOM;
		else if (Nivo.getTezina() == difficulty.NORMAL)
			algoritam = tip_algoritma.BIRA_SMER;
		else if (Nivo.getTezina() == difficulty.HARD)
			algoritam = tip_algoritma.A_ZVEDA;
	}
		
	//PUCANJE
	
	//kreira i dodaje metak za pucanje u jednom smeru
	public void pucaj(float x, float y, int smerM, boolean belo) throws SlickException {
		Metak m=new Metak();
		if (belo) m.setBoja(Color.white);
		else m.setBoja(Color.black);
		if(vrsta == tip_protivnika.HELIKOPTER) {
			if(smerM == 0) m.setMetak(new Image ("res/raketa_dole.png"));
			if(smerM == 1) m.setMetak(new Image ("res/raketa_gore.png"));
			if(smerM == 2) m.setMetak(new Image ("res/raketa_desno.png"));
			if(smerM == 3) m.setMetak(new Image ("res/raketa_levo.png"));
			m.setRaketa(true);
		}
		m.setMetakX(x);
		m.setMetakY(y);	
		m.setSmer(smerM);
		meci.add(m);
		//pucanj.play();
	}
	
	//kreira i dodaje metke za pucanje u osam smera
	public void pucaj8(float x, float y, boolean belo) throws SlickException {
		for(int i=0;i<8;i++) {
			Metak m = new Metak();
			m.setSmer(i);
			if(belo) m.setBoja(Color.white);
			else m.setBoja(Color.black);
			m.setMetakX(x);
			m.setMetakY(y);
			meci.add(m);
		}
		//pucanj.play();
	}
	
	//pucanje puca na igraca zavisno od smera
	public void pucanje(boolean belo) throws SlickException {
		for(int i=0;i<brojTopova;i++) {
			//smer kretanja metka
			//levo
			if(smer == 3) pucaj(protivnikX + kordTop[i].getSmer3X(), protivnikY + kordTop[i].getSmer3Y(), smer, belo);
			//desno
			if(smer == 2) pucaj(protivnikX + kordTop[i].getSmer2X(), protivnikY + kordTop[i].getSmer2Y(), smer, belo);
			//gore
			if(smer == 1) pucaj(protivnikX + kordTop[i].getSmer1X(), protivnikY + kordTop[i].getSmer1Y(), smer, belo);
			//dole
			if(smer == 0) pucaj(protivnikX + kordTop[i].getSmer0X(), protivnikY + kordTop[i].getSmer0Y(), smer, belo);
		}
	}
	
	//sta treba uraditi kada se puca
	public void firing(int smer, boolean belo) throws SlickException {
		if(path == true) {
			pathPucanje--;
			if(pathPucanje == 0) {
				pathPucanje = 30;
				path = false;
			}
		}
		else {
			metakOdbrojavanje--;
			if(metakOdbrojavanje == 0) {
				setSmer(smer);
				promeniAnimaciju();
				pucanje(belo);
				metakOdbrojavanje = 10;
			}
		}
	}
	
	//kada se uoci igraca, puca se na njega
	public void fire(boolean belo) throws SlickException {
		//igrac se nalazi gore
		if(igrac.isZiv()
				&& protivnikX <= igrac.getTenkX() + tenkPomeraj 
				&& protivnikX + protivnikPomerajX >= igrac.getTenkX() - tenkPomeraj 
				&& protivnikY <= igrac.getTenkY()) {
			shooting = true;
			firing(0, belo);
		}
		//igrac se nalazi dole
		else if(igrac.isZiv()
				&& protivnikX <= igrac.getTenkX() + tenkPomeraj 
				&& protivnikX + protivnikPomerajX >= igrac.getTenkX() - tenkPomeraj 
				&& protivnikY > igrac.getTenkY()) {
			shooting = true;
			firing(1, belo);
		}
		//igrac se nalazi levo
		else if(igrac.isZiv()
				&& protivnikY <= igrac.getTenkY() + tenkPomeraj 
				&& protivnikY + protivnikPomerajY >= igrac.getTenkY() - tenkPomeraj 
				&& protivnikX <= igrac.getTenkX()) {
			shooting = true;
			firing(2, belo);
		}
		//igrac se nalazi desno
		else if(igrac.isZiv()
				&& protivnikY <= igrac.getTenkY() + tenkPomeraj 
				&& protivnikY + protivnikPomerajY >= igrac.getTenkY() - tenkPomeraj 
				&& protivnikX > igrac.getTenkX()) {
			shooting = true;
			firing(3, belo);
		}
		else {
			shooting = false;
			stop = false;
		}
		if(imaDvaIgraca) {
			//igrac2 se nalazi gore
			if(igrac2.isZiv() 
					&& protivnikX <= igrac2.getTenkX() + tenkPomeraj 
					&& protivnikX + protivnikPomerajX >= igrac2.getTenkX() - tenkPomeraj 
					&& protivnikY <= igrac2.getTenkY()) {
				shooting2 = true;
				firing(0, belo);
			}
			//igrac2 se nalazi dole
			else if(igrac2.isZiv() 
					&& protivnikX <= igrac2.getTenkX() + tenkPomeraj 
					&& protivnikX + protivnikPomerajX >= igrac2.getTenkX() - tenkPomeraj 
					&& protivnikY > igrac2.getTenkY()) {
				shooting2 = true;
				firing(1, belo);
			}
			//igrac2 se nalazi levo
			else if(igrac2.isZiv() 
					&&protivnikY <= igrac2.getTenkY() + tenkPomeraj 
					&& protivnikY + protivnikPomerajY >= igrac2.getTenkY() - tenkPomeraj 
					&& protivnikX <= igrac2.getTenkX()) {
				shooting2 = true;
				firing(2, belo);
			}
			//igrac2 se nalazi desno
			else if(igrac2.isZiv() 
					&& protivnikY <= igrac2.getTenkY() + tenkPomeraj 
					&& protivnikY + protivnikPomerajY >= igrac2.getTenkY() - tenkPomeraj 
					&& protivnikX > igrac2.getTenkX()) {
				shooting2 = true;
				firing(3, belo);
			}
			else {
				shooting2 = false;
				stop2 = false;
			}
		}
	}
	
	//KRETANJE
	
	//kretanje, kada ovo ne bi postojalo protivnici bi stajali
	public void kreciSe(int delta, Kolizija kolizija) { //kada da se protivnik krece
		if(protivnikX < 1024 && protivnikX > 0 && stop == false && stop2 == false) {
			if(smer == 3) protivnikX -= delta * .1f;
			else if(smer == 2) protivnikX += delta * .1f;
			else if(smer == 1) protivnikY -= delta * .1f;
			else if(smer == 0) protivnikY += delta * .1f;
		}
	}
		
	//ako se udari u kraj nivoa
	public void promenaSmeraKrajNivoa(int delta, Kolizija kolizija) {
		if (algoritam == tip_algoritma.RANDOM) {
			if(protivnikX >= 1024 - sizeX) {
				smer=3;
				if(!blk) promeniAnimaciju();
				protivnikX -= delta * .1f;
			}
			else if(protivnikX <= zid2) {
				smer=2;
				if(!blk) promeniAnimaciju();
				protivnikX+= delta * .1f;
			}
			if(protivnikY >= 768 - sizeY) {
				smer=1;
				if(!blk) promeniAnimaciju();
				protivnikY -= delta * .1f;
			}
			else if(protivnikY <= zid) {
				smer=0;
				if(!blk) promeniAnimaciju();
				protivnikY+= delta * .1f;
			}
		}
		else if (algoritam == tip_algoritma.BIRA_SMER) { 
			if(protivnikX > 1024 - sizeX || protivnikX <= zid2 || protivnikY >= 768 - sizeY || protivnikY <= zid) {
				LinkedList<Objekat> listaPom;
				if(this.getVrsta() == tip_protivnika.PODMORNICA) listaPom = kolizija.getObjekatVoda();
				else listaPom = kolizija.getObjekatList();
				float max = 0;
				int stariSmer = smer;
				int pomSmer = 0;
				if(stariSmer == 0) protivnikY -= delta * .1f;
				if(stariSmer == 1) protivnikY += delta * .1f;
				if(stariSmer == 2) protivnikX -= delta * .1f;
				if(stariSmer == 3) protivnikX += delta * .1f;
				float X = protivnikX;
				float Y = protivnikY;
				for(int i=0;i<4;i++) {
					if(i == smer) continue;//preskace se smer u kome se vec krece
					float pom = 0;//pomeraj u odnosu na pocetak
					float Xpom = X;//pomocna promenljiva u koju se izracunava x koordinata
					float Ypom = Y;//pomocna promenljiva u koju se izracunava y koordinata
					while(this.getNivo().moze(listaPom, Xpom, Ypom)) {
						if(i == 0) Ypom += delta * .1f;
						if(i == 1) Ypom -= delta * .1f;
						if(i == 2) Xpom += delta * .1f;
						if(i == 3) Xpom -= delta * .1f;
						//ako se dodje do ivice ekrana prekida se petlja
						//inace bi se uslo u beskonacnu petlju
						if(Xpom < zid2 || Xpom > 1024 - sizeX || Ypom < zid || Ypom > 768 - sizeY) break;
					}
					//racuna se pomeraj
					if(i == 0) pom = Ypom - Y;
					if(i == 1) pom = Y - Ypom;
					if(i == 2) pom = Xpom - X;
					if(i == 3) pom = X - Xpom;
					if(pom > max) {
						max = pom;
						pomSmer = i;
					}				
				}
				smer = pomSmer;
				if(!blk) promeniAnimaciju();
			}
			/*else {
				if(protivnikX > 1024 - sizeX || protivnikX <= zid2 || protivnikY >= 768 - sizeY || protivnikY <= zid) {
					LinkedList<Objekat> listaPom;
					if(this.getVrsta() == tip_protivnika.PODMORNICA) listaPom = kolizija.getObjekatVoda();
					else listaPom = kolizija.getObjekatList();
					float max = 0;
					int stariSmer = smer;
					int pomSmer = 0;
					if(stariSmer == 0) protivnikY -= delta * .1f;
					if(stariSmer == 1) protivnikY += delta * .1f;
					if(stariSmer == 2) protivnikX -= delta * .1f;
					if(stariSmer == 3) protivnikX += delta * .1f;
					float X = protivnikX;
					float Y = protivnikY;
					for(int i=0;i<4;i++) {
						if(i == smer) continue;//preskace se smer u kome se vec krece
						float pom = 0;//pomeraj u odnosu na pocetak
						float Xpom = X;//pomocna promenljiva u koju se izracunava x koordinata
						float Ypom = Y;//pomocna promenljiva u koju se izracunava y koordinata
						while(this.getNivo().moze(listaPom, Xpom, Ypom)) {
							if(i == 0) Ypom += delta * .1f;
							if(i == 1) Ypom -= delta * .1f;
							if(i == 2) Xpom += delta * .1f;
							if(i == 3) Xpom -= delta * .1f;
							//ako se dodje do ivice ekrana prekida se petlja
							//inace bi se uslo u beskonacnu petlju
							if(Xpom < zid2 || Xpom > 1024 - sizeX || Ypom < zid || Ypom > 768 - sizeY) break;
						}
						//racuna se pomeraj
						if(i == 0) pom = Ypom - Y;
						if(i == 1) pom = Y - Ypom;
						if(i == 2) pom = Xpom - X;
						if(i == 3) pom = X - Xpom;
						if(pom > max) {
							max = pom;
							pomSmer = i;
						}				
					}
					smer = pomSmer;
					if(!blk) promeniAnimaciju();
				}
			}*/
		}
		else {
			//treci algoritam
			if(protivnikX > 1024 - sizeX || protivnikX <= zid2 || protivnikY >= 768 - sizeY || protivnikY <= zid) {
				LinkedList<Objekat> listaPom;
				if(this.getVrsta() == tip_protivnika.PODMORNICA) listaPom = kolizija.getObjekatVoda();
				else listaPom = kolizija.getObjekatList();
				float max = 0;
				int stariSmer = smer;
				int pomSmer = 0;
				if(stariSmer == 0) protivnikY -= delta * .1f;
				if(stariSmer == 1) protivnikY += delta * .1f;
				if(stariSmer == 2) protivnikX -= delta * .1f;
				if(stariSmer == 3) protivnikX += delta * .1f;
				//bira smer na osnovu prepreka i protivnika
				LinkedList<Float> kordX = new LinkedList<Float>();//x koordinate protivnika
				LinkedList<Float> kordY = new LinkedList<Float>();//y koordinate protivnika
				kordX.clear();
				kordY.clear();
				//prikupljanje trenutnih koordinata protivnika
				getNivo().pokupiKoordinate(kordX, kordY);
				float X = protivnikX;
				float Y = protivnikY;
				for(int i=0;i<4;i++) {
					if(i == smer) continue;//preskace se smer u kome se vec krece
					float pom = 0;//pomeraj u odnosu na pocetak
					float Xpom = X;//pomocna promenljiva u koju se izracunava x koordinata
					float Ypom = Y;//pomocna promenljiva u koju se izracunava y koordinata
					while(this.getNivo().moze(listaPom, Xpom, Ypom)
							|| this.getNivo().mozeProtivnik(this, kordX, kordY)) {
						if(i == 0) Ypom += delta * .1f;
						if(i == 1) Ypom -= delta * .1f;
						if(i == 2) Xpom += delta * .1f;
						if(i == 3) Xpom -= delta * .1f;
						//ako se dodje do ivice ekrana prekida se petlja
						//inace bi se uslo u beskonacnu petlju
						if(Xpom < zid2 || Xpom > 1024 - sizeX || Ypom < zid || Ypom > 768 - sizeY) break;
						getNivo().azurirajKoordinate(this, kordX, kordY, delta);
					}
					//racuna se pomeraj
					if(i == 0) pom = Ypom - Y;
					if(i == 1) pom = Y - Ypom;
					if(i == 2) pom = Xpom - X;
					if(i == 3) pom = X - Xpom;
					if(pom > max) {
						max = pom;
						pomSmer = i;
					}				
				}
				smer = pomSmer;
				if(!blk) promeniAnimaciju();
			}
			/*else {
				if(protivnikX > 1024 - sizeX || protivnikX <= zid2 || protivnikY >= 768 - sizeY || protivnikY <= zid) {
					LinkedList<Objekat> listaPom;
					if(this.getVrsta() == tip_protivnika.PODMORNICA) listaPom = kolizija.getObjekatVoda();
					else listaPom = kolizija.getObjekatList();
					float max = 0;
					int stariSmer = smer;
					int pomSmer = 0;
					if(stariSmer == 0) protivnikY -= delta * .1f;
					if(stariSmer == 1) protivnikY += delta * .1f;
					if(stariSmer == 2) protivnikX -= delta * .1f;
					if(stariSmer == 3) protivnikX += delta * .1f;
					float X = protivnikX;
					float Y = protivnikY;
					for(int i=0;i<4;i++) {
						if(i == smer) continue;//preskace se smer u kome se vec krece
						float pom = 0;//pomeraj u odnosu na pocetak
						float Xpom = X;//pomocna promenljiva u koju se izracunava x koordinata
						float Ypom = Y;//pomocna promenljiva u koju se izracunava y koordinata
						while(this.getNivo().moze(listaPom, Xpom, Ypom)) {
							if(i == 0) Ypom += delta * .1f;
							if(i == 1) Ypom -= delta * .1f;
							if(i == 2) Xpom += delta * .1f;
							if(i == 3) Xpom -= delta * .1f;
							//ako se dodje do ivice ekrana prekida se petlja
							//inace bi se uslo u beskonacnu petlju
							if(Xpom < zid2 || Xpom > 1024 - sizeX || Ypom < zid || Ypom > 768 - sizeY) break;
						}
						//racuna se pomeraj
						if(i == 0) pom = Ypom - Y;
						if(i == 1) pom = Y - Ypom;
						if(i == 2) pom = Xpom - X;
						if(i == 3) pom = X - Xpom;
						//System.out.println("POM "+i+" "+pom);
						if(pom > max) {
							max = pom;
							pomSmer = i;
						}				
					}
					smer = pomSmer;
					if(!blk) promeniAnimaciju();
				}
			}*/
		}
	}
	
	//promena smera kretanja
	public void promeniSmer(int delta, Kolizija kolizija) {
		if(algoritam == tip_algoritma.RANDOM) {
			if (shooting == true) {
				if(stop == false) {
					if(smer == 0) protivnikY -= delta * .1f;
					if(smer == 1) protivnikY += delta * .1f;
					if(smer == 2) protivnikX -= delta * .1f;
					if(smer == 3) protivnikX += delta * .1f;
				}
				stop = true;
			}
			else if (shooting2 == true) {
				if(stop2 == false) {
					if(smer == 0) protivnikY -= delta * .1f;
					if(smer == 1) protivnikY += delta * .1f;
					if(smer == 2) protivnikX -= delta * .1f;
					if(smer == 3) protivnikX += delta * .1f;
				}
				stop2 = true;
			}
			else 
				if(smer == 2)	{
					smer = 3;
					promeniAnimaciju();
					protivnikX -= delta * .1f;
				}
				else if(smer == 3) {
					smer = 2;
					promeniAnimaciju();
					protivnikX += delta * .1f;
				}
				else if(smer == 1) {
					smer = 0;
					promeniAnimaciju();
					protivnikY += delta * .1f;
				}
				else if(smer == 0) {
					smer = 1;
					promeniAnimaciju();
					protivnikY -= delta * .1f;
				}
		}
		else if(algoritam == tip_algoritma.BIRA_SMER) {
			if (shooting == true) {
				if(stop == false) {
					if(smer == 0) protivnikY -= delta * .1f;
					if(smer == 1) protivnikY += delta * .1f;
					if(smer == 2) protivnikX -= delta * .1f;
					if(smer == 3) protivnikX += delta * .1f;
				}
				stop = true;
			}
			else if (shooting2 == true) {
				if(stop2 == false) {
					if(smer == 0) protivnikY -= delta * .1f;
					if(smer == 1) protivnikY += delta * .1f;
					if(smer == 2) protivnikX -= delta * .1f;
					if(smer == 3) protivnikX += delta * .1f;
				}
				stop2 = true;
			}
			else {
				LinkedList<Objekat> listaPom;
				if(this.getVrsta() == tip_protivnika.PODMORNICA) listaPom = kolizija.getObjekatVoda();
				else listaPom = kolizija.getObjekatList();
				float max = 0;
				int stariSmer = smer;
				int pomSmer = 0;
				if(stariSmer == 0) protivnikY -= delta * .1f;
				if(stariSmer == 1) protivnikY += delta * .1f;
				if(stariSmer == 2) protivnikX -= delta * .1f;
				if(stariSmer == 3) protivnikX += delta * .1f;
				float X = protivnikX;
				float Y = protivnikY;
				for(int i=0;i<4;i++) {
					if(i == smer) continue;//preskace se smer u kome se vec krece
					float pom = 0;//pomeraj u odnosu na pocetak
					float Xpom = X;//pomocna promenljiva u koju se izracunava x koordinata
					float Ypom = Y;//pomocna promenljiva u koju se izracunava y koordinata
					while(this.getNivo().moze(listaPom, Xpom, Ypom)) {
						if(i == 0) Ypom += delta * .1f;
						if(i == 1) Ypom -= delta * .1f;
						if(i == 2) Xpom += delta * .1f;
						if(i == 3) Xpom -= delta * .1f;
						//ako se dodje do ivice ekrana prekida se petlja
						//inace bi se uslo u beskonacnu petlju
						if(Xpom < zid2 || Xpom > 1024 - sizeX || Ypom < zid || Ypom > 768 - sizeY) break;
					}
					//racuna se pomeraj
					if(i == 0) pom = Ypom - Y;
					if(i == 1) pom = Y - Ypom;
					if(i == 2) pom = Xpom - X;
					if(i == 3) pom = X - Xpom;
					if(pom > max) {
						max = pom;
						pomSmer = i;
					}				
				}
				smer = pomSmer;
				if(!blk) promeniAnimaciju();
			}
		}
		
		//ovde pocinje treci algoritam
		else {
			LinkedList<Objekat> listaPom;
			if(this.getVrsta() == tip_protivnika.PODMORNICA) listaPom = kolizija.getObjekatVoda();
			else listaPom = kolizija.getObjekatList();
			int pomeraj = pomerajPathfinding(smer, protivnikX, protivnikY, listaPom);
			if (shooting == true) {
				if(stop == false) {
					if(smer == 0) protivnikY -= delta * .1f;
					if(smer == 1) protivnikY += delta * .1f;
					if(smer == 2) protivnikX -= delta * .1f;
					if(smer == 3) protivnikX += delta * .1f;
				}
				if(getNivo().mozeDaZaobidje(listaPom, poslednjeUdario, smer) 
						&& traziPut
						&& pomeraj != 0 ) {
					float targetX = protivnikX;
					float targetY = protivnikY;
					if(smer == 0) targetY += pomeraj;
					else if(smer == 1) targetY -= pomeraj;
					else if(smer == 2) targetX += pomeraj;
					else targetX -= pomeraj;
					pathfinding(protivnikX, protivnikY, targetX, targetY, delta, kolizija);
				}
				else stop = true;
			}
//			else if (shooting2 == true) {
//				if(stop2 == false) {
//					if(smer == 0) protivnikY -= delta * .1f;
//					if(smer == 1) protivnikY += delta * .1f;
//					if(smer == 2) protivnikX -= delta * .1f;
//					if(smer == 3) protivnikX += delta * .1f;
//				}
//				stop2 = true;
//			}
			else {
				if(smer == 0) protivnikY -= delta * .1f;
				if(smer == 1) protivnikY += delta * .1f;
				if(smer == 2) protivnikX -= delta * .1f;
				if(smer == 3) protivnikX += delta * .1f; 
				float max = 0;
				int stariSmer = smer;
				int pomSmer = 0;
				if(stariSmer == 0) protivnikY -= delta * .1f;
				if(stariSmer == 1) protivnikY += delta * .1f;
				if(stariSmer == 2) protivnikX -= delta * .1f;
				if(stariSmer == 3) protivnikX += delta * .1f;
				//bira smer na osnovu prepreka i protivnika
				LinkedList<Float> kordX = new LinkedList<Float>();//x koordinate protivnika
				LinkedList<Float> kordY = new LinkedList<Float>();//y koordinate protivnika
				kordX.clear();
				kordY.clear();
				//prikupljanje trenutnih koordinata protivnika
				getNivo().pokupiKoordinate(kordX, kordY);
				float X = protivnikX;
				float Y = protivnikY;
				for(int i=0;i<4;i++) {
					if(i == smer) continue;//preskace se smer u kome se vec krece
					float pom = 0;//pomeraj u odnosu na pocetak
					float Xpom = X;//pomocna promenljiva u koju se izracunava x koordinata
					float Ypom = Y;//pomocna promenljiva u koju se izracunava y koordinata
					while(this.getNivo().moze(listaPom, Xpom, Ypom)
							|| this.getNivo().mozeProtivnik(this, kordX, kordY)) {
						if(i == 0) Ypom += delta * .1f;
						if(i == 1) Ypom -= delta * .1f;
						if(i == 2) Xpom += delta * .1f;
						if(i == 3) Xpom -= delta * .1f;
						//ako se dodje do ivice ekrana prekida se petlja
						//inace bi se uslo u beskonacnu petlju
						if(Xpom < zid2 || Xpom > 1024 - sizeX || Ypom < zid || Ypom > 768 - sizeY) break;
						getNivo().azurirajKoordinate(this, kordX, kordY, delta);
					}
					//racuna se pomeraj
					if(i == 0) pom = Ypom - Y;
					if(i == 1) pom = Y - Ypom;
					if(i == 2) pom = Xpom - X;
					if(i == 3) pom = X - Xpom;
					if(pom > max) {
						max = pom;
						pomSmer = i;
					}				
				}
				smer = pomSmer;
				if(!blk) promeniAnimaciju();
			}
		}
	}
	
	public int odrediSmer(int delta, Kolizija kolizija) {;
		int smer = 0;
		if(algoritam == tip_algoritma.RANDOM) {
			smer = ((int)(Math.random()*3));
		}
		else if(algoritam == tip_algoritma.BIRA_SMER) {
			//bira smer na osnovu prepreka
			//protivnici ce biti ukljuceni u sledecem algoritmu
			LinkedList<Objekat> listaPom;
			if(this.getVrsta() == tip_protivnika.PODMORNICA) listaPom = kolizija.getObjekatVoda();
			else listaPom = kolizija.getObjekatList();
			float max = 0;
			float X = protivnikX;
			float Y = protivnikY;
			for(int i=0;i<4;i++) {
				float pom = 0;//pomeraj u odnosu na pocetak
				float Xpom = X;//pomocna promenljiva u koju se izracunava x koordinata
				float Ypom = Y;//pomocna promenljiva u koju se izracunava y koordinata
				while(this.getNivo().moze(listaPom, Xpom, Ypom)) {
						//|| !this.getNivo().mozeProtivnik(this, delta)
						//|| !this.getNivo().mozeJa(this)) {
					if(i == 0) Ypom += delta * .1f;
					if(i == 1) Ypom -= delta * .1f;
					if(i == 2) Xpom += delta * .1f;
					if(i == 3) Xpom -= delta * .1f;
					//ako se dodje do ivice ekrana prekida se petlja
					//inace bi se uslo u beskonacnu petlju
					if(Xpom <0 || Xpom > 1024 || Ypom < 50 || Ypom > 768) break;
				}
				//racuna se pomeraj
				if(i == 0) pom = Ypom - Y;
				if(i == 1) pom = Y - Ypom;
				if(i == 2) pom = Xpom - X;
				if(i == 3) pom = X - Xpom;
				if(pom >= max) {
					max = pom;
					smer = i;
				}				
			}
		}
		else { 
			//bira smer na osnovu prepreka
			LinkedList<Float> kordX = new LinkedList<Float>();//x koordinate protivnika
			LinkedList<Float> kordY = new LinkedList<Float>();//y koordinate protivnika
			kordX.clear();
			kordY.clear();
			//prikupljanje trenutnih koordinata protivnika
			getNivo().pokupiKoordinate(kordX, kordY);
			LinkedList<Objekat> listaPom;
			if(this.getVrsta() == tip_protivnika.PODMORNICA) listaPom = kolizija.getObjekatVoda();
			else listaPom = kolizija.getObjekatList();
			float max = 0;
			float X = protivnikX;
			float Y = protivnikY;
			for(int i=0;i<4;i++) {
				float pom = 0;//pomeraj u odnosu na pocetak
				float Xpom = X;//pomocna promenljiva u koju se izracunava x koordinata
				float Ypom = Y;//pomocna promenljiva u koju se izracunava y koordinata
				while(this.getNivo().moze(listaPom, Xpom, Ypom)
						|| this.getNivo().mozeProtivnik(this, kordX, kordY)) {
					if(i == 0) Ypom += delta * .1f;
					if(i == 1) Ypom -= delta * .1f;
					if(i == 2) Xpom += delta * .1f;
					if(i == 3) Xpom -= delta * .1f;
					//ako se dodje do ivice ekrana prekida se petlja
					//inace bi se uslo u beskonacnu petlju
					if(Xpom <zid2 || Xpom > 1024 - sizeX || Ypom < zid || Ypom > 768 - sizeY) break;
					getNivo().azurirajKoordinate(this, kordX, kordY, delta);
				}
				//racuna se pomeraj
				if(i == 0) pom = Ypom - Y;
				if(i == 1) pom = Y - Ypom;
				if(i == 2) pom = Xpom - X;
				if(i == 3) pom = X - Xpom;
				if(pom > max) {
					max = pom;
					smer = i;
				}				
			}
		}
		return smer;
	}
	
	public int pomerajPathfinding(int smer, float x, float y, LinkedList<Objekat> lista) {
		int pomeraj = 105;
		int pom = 50;//pomocna promenljiva, ukoliko ne moze na iicijalni pomeraj dodaje se
		int zabranjeno = 0;
		boolean kraj = true;
		if (vrsta == tip_protivnika.BOSS) return zabranjeno;
		if(smer == 0) {
			y+=pomeraj;
			if(this.getNivo().moze(lista, x, y)) return pomeraj;
			while(kraj) {
				y+=pom;
				pomeraj+=pom;
				if(this.getNivo().moze(lista, x, y)) return pomeraj;
				if( y + sizeY > 768) return zabranjeno;
			}
		}
		else if(smer == 1) {
			y-=pomeraj;
			if(this.getNivo().moze(lista, x, y)) return pomeraj;
			while(kraj) {
				y-=pom;
				pomeraj+=pom;
				if(this.getNivo().moze(lista, x, y)) return pomeraj;
				if(y < zid) return zabranjeno;
			}
		}
		else if(smer == 2) {
			x+=pomeraj;
			if(this.getNivo().moze(lista, x, y)) return pomeraj;
			while(kraj) {
				x+=pom;
				pomeraj+=pom;
				if(this.getNivo().moze(lista, x, y)) return pomeraj;
				if(x + sizeX > 1024) return zabranjeno;
			}
		}
		else {
			x-=pomeraj;
			if(this.getNivo().moze(lista, x, y)) return pomeraj;
			while(kraj) {
				x-=pom;
				pomeraj+=pom;
				if(this.getNivo().moze(lista, x, y)) return pomeraj;
				if(x < 0) return zabranjeno;
			}
		}
		return pomeraj;
	}
	
	//algoritam po kome se menja smer kretanja nakon nekog vremena
	public void algoritamKretanja(int delta, Kolizija kolizija) {
		//koliko dugo da se krece u jednom smeru
		smerOdbrojavanje--;
		//kada se dodje do kraja promeni se smer
		if(smerOdbrojavanje == 0) {
			smer = odrediSmer(delta, kolizija);
			smerOdbrojavanje = 200;
			if (!blk) promeniAnimaciju();
		}
	}
	
	public void pathfinding(float startX, float startY, float targetX, float targetY, int delta, Kolizija kolizija) {
		//System.out.println("Trazim put");
		trenutniCvorovi.clear();
		put.clear();
		duzinaPuta = 0;
		indexCvora = 0;
		//System.out.println("START X: "+startX);
		//System.out.println("START Y: "+startY);
		//System.out.println("TARGET X: "+targetX);
		//System.out.println("TARGET Y: "+targetY);
		
		//targetX -= startX;
		//targetY -= startY;
		
		boolean kraj = true;//ovo bi trebalo da bude uslov za izlazak iz petlje
		int index = 0;
		int tempIndex = -1;
		float minFunkcija = 10000f;
		
		boolean prvi;
		
		if(Math.abs(targetX-startX) < Math.abs(targetY-startY)) prvi = false;
		else prvi = true;
		
		//kolizija
		LinkedList<Objekat> listaPom = kolizija.getObjekatList();
		
		//pocetni cvor
		Cvor sledeciCvor = new Cvor();//sledeci Cvor od kojeg se proverava uslov
		sledeciCvor.setX(startX);
		sledeciCvor.setY(startY);
		
		//System.out.println("X: "+sledeciCvor.getX());
		//System.out.println("Y: "+sledeciCvor.getY());
		
		put.add(sledeciCvor);
		
		//pocetak pretrage
		Cvor pom;
		for(int i=0; i<4; i++) {
			pom = new Cvor();
			pom.setRoditelj(sledeciCvor);
			float pomX = pom.getRoditelj().getX();
			float pomY = pom.getRoditelj().getY();
			float korak = delta * .1f;
			//proverava se da li cvorovi mogu da udju u listu
//				if(this.getNivo().moze(listaPom, pomX, pomY)) {
//					if(i==0) pomY += delta * .1f;
//					if(i==1) pomY -= delta * .1f;
//					if(i==2) pomX += delta * .1f;
//					if(i==3) pomX -= delta * .1f;
//				}
			if(i==0) {
				if(this.getNivo().moze(listaPom, pomX, pomY + delta * .1f)) {
					pomY += delta * .1f;
				}
				else continue;
			}
			if(i==1) {
				if(this.getNivo().moze(listaPom, pomX, pomY - delta * .1f)) {
					pomY -= delta * .1f;
				}
				else continue;
			} 
			if(i==2) {
				if(this.getNivo().moze(listaPom, pomX + delta * .1f, pomY)) {
					pomX += delta * .1f;
				}
				else continue;
					
			} 
			if(i==3) {
				if(this.getNivo().moze(listaPom, pomX - delta * .1f, pomY)) {
					pomX -= delta * .1f;
				}
				else continue;
			}
			pom.setX(pomX);
			pom.setY(pomY);
			pom.setSmer(i);
			pom.setHeuristika(targetX, targetY, korak);
			//pom.setPomeraj(korak);
			pom.setPomeraj(korak);
			pom.setFunkcija();
			trenutniCvorovi.add(pom);
		}
		//ispisiCvorove2();
		System.out.println("PRVI KORAK");
		//pretraga dodatih cvorova
		for(Iterator<Cvor> i = trenutniCvorovi.iterator();i.hasNext();) {
			pom = i.next();
			tempIndex++;
			if(prvi) {
				//if(pom.getHeuristika() < minFunkcija && pom.getRoditelj() == sledeciCvor) {
				if(pom.getFunkcija() < minFunkcija) {
					index = tempIndex;
					minFunkcija = pom.getFunkcija();
				}
			}
			else {
				//if(pom.getHeuristika() <= minFunkcija && pom.getRoditelj() == sledeciCvor) {
				if(pom.getFunkcija() <= minFunkcija) {
					index = tempIndex;
					minFunkcija = pom.getFunkcija();
				}
			}
		}
		//System.out.println("min funkcija" + minFunkcija);
		sledeciCvor = trenutniCvorovi.get(index);
		trenutniCvorovi.remove(index);//cvor se uklanja iz liste trenutnih cvorova
		put.add(sledeciCvor);//cvor se dodaje u listu cvorova puta
		duzinaPuta++;
		
		//System.out.println("X: "+sledeciCvor.getX());
		//System.out.println("Y: "+sledeciCvor.getY());
		//System.out.println("SMER "+sledeciCvor.getSmer());
		
		//nastavak pretrage
		while(kraj) {
			for(int i=0; i<4; i++) {
				pom = new Cvor();
				pom.setRoditelj(sledeciCvor);
				float pomX = sledeciCvor.getX();
				float pomY = sledeciCvor.getY();
				float korak = delta * .1f;
				//proverava se da li cvorovi mogu da udju u listu
				/*if(this.getNivo().moze(listaPom, pomX, pomY)) {
					//mozeLista = true;
					if(i==0) pomY += delta * .1f;
					if(i==1) pomY -= delta * .1f;
					if(i==2) pomX += delta * .1f;
					if(i==3) pomX -= delta * .1f;
				}
				else continue;*/
				if(i==0) {
					if(this.getNivo().moze(listaPom, pomX, pomY + delta * .1f)
							&& (pomY + delta * .1f) < 768){
						pomY += delta * .1f;
					}
					else continue;
				}
				if(i==1) {
					if(this.getNivo().moze(listaPom, pomX, pomY - delta * .1f)
							&& (pomY - delta * .1f) > zid) {
						pomY -= delta * .1f;
					}
					else continue;
				} 
				if(i==2) {
					if(this.getNivo().moze(listaPom, pomX + delta * .1f, pomY)
							&& (pomX + delta * .1f) < 1024) {
						pomX += delta * .1f;
					}
					else continue;
						
				} 
				if(i==3) {
					if(this.getNivo().moze(listaPom, pomX - delta * .1f, pomY)
							&& (pomX + delta * .1f) > zid2) {
						pomX -= delta * .1f;
					}
					else continue;
				}
				pom.setX(pomX);
				pom.setY(pomY);
				pom.setSmer(i);
				//pom.setPomeraj(korak);
				pom.setPomeraj(1);
				if(!cvorPuta(pom)) {
					if(cvorLista(pom)) {
						Cvor isti = dohvatiIstiCvor(pom);
						if(pom.getPomeraj() <= isti.getPomeraj()) {
							izmeni(isti, sledeciCvor, korak, i);
						}
					}
					else {
						pom.setHeuristika(targetX, targetY, korak);
						pom.setFunkcija();
						trenutniCvorovi.add(pom);
					}
				}
			}
			index = 0;
			tempIndex = -1;
			minFunkcija = 10000f;
			//pretraga dodatih cvorova
			for(Iterator<Cvor> i = trenutniCvorovi.iterator();i.hasNext();) {
				pom = i.next();
				tempIndex++;
				if(prvi) {
					//if(pom.getHeuristika() < minFunkcija && pom.getRoditelj() == sledeciCvor) {
					if(pom.getFunkcija() < minFunkcija && pom.getRoditelj() == sledeciCvor) {
						index = tempIndex;
						minFunkcija = pom.getFunkcija();
					}
				}
				else {
					//if(pom.getHeuristika() <= minFunkcija && pom.getRoditelj() == sledeciCvor) {
					if(pom.getFunkcija() <= minFunkcija && pom.getRoditelj() == sledeciCvor) {
						index = tempIndex;
						minFunkcija = pom.getFunkcija();
					}
				}
			}
			sledeciCvor = trenutniCvorovi.get(index);
			trenutniCvorovi.remove(index);
			put.add(sledeciCvor);
			duzinaPuta++;
			
			//System.out.println("X: "+sledeciCvor.getX());
			//System.out.println("Y: "+sledeciCvor.getY());
			//System.out.println("SMER "+sledeciCvor.getSmer());
			
			if( (sledeciCvor.getX() == targetX  &&  sledeciCvor.getY() == targetY)
					|| trenutniCvorovi.isEmpty()) kraj = false;
		}
		tekCvor = put.get(indexCvora++);
		traziPut = false;
		path = true;
		ispisiCvorove();
		//System.out.println("Nasao put");
	}
	
	public void ispisiCvorove() {
		for(Iterator<Cvor> i = put.iterator();i.hasNext();) {
			Cvor pom = i.next();
			System.out.println("CVOR");
			System.out.println("X "+pom.getX());
			System.out.println("Y "+pom.getY());
			System.out.println("SMER "+pom.getSmer());
			System.out.println("MIN FUNKCIJA "+pom.getFunkcija());
		}
	}
	
	public boolean cvorLista(Cvor c) { //proverava da li se cvor nalazi u listi
		Cvor pom = new Cvor();
		for(Iterator<Cvor> i = trenutniCvorovi.iterator();i.hasNext();) {
			pom = i.next();
			if( pom.getX() == c.getX() && pom.getY() == c.getY()) return true;
		}
		return false;
	}
	
	public boolean cvorPuta(Cvor c) { //proverava da li se cvor nalazi u listi
		Cvor pom;// = new Cvor();
		for(Iterator<Cvor> i = put.iterator();i.hasNext();) {
			pom = i.next();
			if( pom.getX() == c.getX() && pom.getY() == c.getY()) return true;
		}
		return false;
	}
	
	public Cvor dohvatiIstiCvor(Cvor c) { //proverava da li se cvor nalazi u listi
		Cvor pom;// = new Cvor();
		for(Iterator<Cvor> i = trenutniCvorovi.iterator();i.hasNext();) {
			pom = i.next();
			if( pom.getX() == c.getX() && pom.getY() == c.getY()) return pom;
		}
		return null;
	}
	
	public void izmeni(Cvor c, Cvor roditelj, float korak, int smer) { //proverava da li se cvor nalazi u listi
		Cvor pom;// = new Cvor();
		for(Iterator<Cvor> i = trenutniCvorovi.iterator();i.hasNext();) {
			pom = i.next();
			if( pom.getX() == c.getX() && pom.getY() == c.getY()) {
				pom.setRoditelj(roditelj);
				pom.setSmer(smer);
				pom.setPomeraj(korak);
				pom.setFunkcija();
			}
		}
	}
	
	public void kreciSePoPutu(int delta) {
		//Cvor pom;
		if(path) {
			if(duzinaPuta > indexCvora) {
				smer = tekCvor.getSmer();
				promeniAnimaciju();
				if(smer == 3) protivnikX -= delta * .1f;
				else if(smer == 2) protivnikX += delta * .1f;
				else if(smer == 1) protivnikY -= delta * .1f;
				else if(smer == 0) protivnikY += delta * .1f;
				tekCvor = put.get(indexCvora++);
			}
			else path = false;
		}
	}
		
	//CRTANJE
	
	//crtanje eksplozije
	public void eksplodiraj () {
		eksplozija.draw(protivnikX, protivnikY);
		eksplozija.setLooping(false);
	}
	
	//crtanje protivnika
	public void crtaj(Graphics g) throws SlickException {
		protivnik.draw(protivnikX, protivnikY);
	}
	
	//promena animacje
	public void promeniAnimaciju () {
		if (smer == 0) protivnik = movingDown;
		if (smer == 1) protivnik = movingUp;
		if (smer == 2) protivnik = movingRight;
		if (smer == 3) protivnik = movingLeft;
	}
	
	//OSTALE METODE
	
	//ozivljavanje protivnika, treba kada se pogine pa se nastavlja igra
	public void ozivi() {
		ubiven = false;
		smer = 0;
		setProtivnik(movingDown);
		smerOdbrojavanje = 500;
		metakOdbrojavanje = 1;
		meci.clear();
		eksplozija.setLooping(true);
		eksplozija.restart();
		shooting = false;
		shooting2 = false;
		stop = false;
		stop2 = false;
	}
	
	//dodavanje topa iz kojeg se puca u niz topova
	public void dodajTop(int index, int smer0X, int smer0Y, int smer1X, int smer1Y, 
			int smer2X, int smer2Y, int smer3X, int smer3Y) {
		kordTop[index] = new KoordinateTopova(smer0X, smer0Y, smer1X, smer1Y, smer2X, smer2Y, smer3X, smer3Y);
	}
	
	//BROJAC ZA OZIVLJAVANJE
	public boolean isTime () {
		if (survivorCount > 0) {
			survivorCount--;
			return false;
		}
		else {
			survivorCount = 120;
			return true;
		}
	}
	
	//APSTRAKTNE METODE
	
	//postavljanje animacije
	public void setAnimation() throws SlickException {}
	
	//kretanje
	public void move(int delta, Kolizija kolizija) {}
	
	//AI protivnika
	public void protivnikAI(int delta, Kolizija kolizija, boolean belo) throws SlickException {}
	
}
